home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Samples / C++ / Direct3D / PRTPerVertex / PRTMesh.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-28  |  32.6 KB  |  827 lines
  1. //--------------------------------------------------------------------------------------
  2. // File: PRTOptionsDlg.cpp
  3. //
  4. // Copyright (c) Microsoft Corporation. All rights reserved.
  5. //--------------------------------------------------------------------------------------
  6. #include "dxstdafx.h"
  7. #include "prtmesh.h"
  8. #include <stdio.h>
  9.  
  10. //#define DEBUG_VS   // Uncomment this line to debug vertex shaders 
  11. //#define DEBUG_PS   // Uncomment this line to debug pixel shaders 
  12.  
  13.  
  14.  
  15. //--------------------------------------------------------------------------------------
  16. CPRTMesh::CPRTMesh(void)
  17. {
  18.     m_pMesh          = NULL;
  19.     m_pPRTBuffer     = NULL;
  20.     m_pPRTCompBuffer = NULL;
  21.     m_pPRTEffect    = NULL;       
  22.     m_pSHIrradEnvMapEffect = NULL;       
  23.     m_pNDotLEffect  = NULL;       
  24.     m_fObjectRadius = 0.0f;
  25.     m_vObjectCenter = D3DXVECTOR3(0,0,0);
  26.     m_aClusterBases = NULL;
  27.     m_dwOrder       = 0;
  28.     m_aPRTConstants = NULL;
  29.     m_pMaterials    = NULL;
  30.     m_dwNumMaterials = 0;
  31.  
  32.     ZeroMemory( &m_ReloadState, sizeof(RELOAD_STATE) );
  33. }
  34.  
  35.  
  36. //--------------------------------------------------------------------------------------
  37. CPRTMesh::~CPRTMesh(void)
  38. {
  39.     Cleanup();
  40. }
  41.  
  42.  
  43. //--------------------------------------------------------------------------------------
  44. HRESULT CPRTMesh::OnCreateDevice( LPDIRECT3DDEVICE9 pd3dDevice )
  45. {
  46.     if( m_ReloadState.bUseReloadState )
  47.     {
  48.         LoadMesh( pd3dDevice, m_ReloadState.strMeshFileName );
  49.         if( m_ReloadState.bLoadCompressed )
  50.         {
  51.             LoadCompPRTBufferFromFile( m_ReloadState.strPRTBufferFileName );
  52.         }
  53.         else
  54.         {
  55.             LoadPRTBufferFromFile( m_ReloadState.strPRTBufferFileName );
  56.             CompressBuffer( m_ReloadState.quality, m_ReloadState.dwNumClusters, m_ReloadState.dwNumPCA );
  57.         }
  58.         ExtractCompressedDataForPRTShader();
  59.         LoadEffects( pd3dDevice, DXUTGetDeviceCaps() );
  60.     }
  61.  
  62.     return S_OK;
  63. }
  64.  
  65.  
  66. //--------------------------------------------------------------------------------------
  67. HRESULT CPRTMesh::OnResetDevice()
  68. {
  69.     HRESULT hr;
  70.     if( m_pPRTEffect )
  71.         V( m_pPRTEffect->OnResetDevice() );
  72.     if( m_pSHIrradEnvMapEffect )
  73.         V( m_pSHIrradEnvMapEffect->OnResetDevice() );
  74.     if( m_pNDotLEffect )
  75.         V( m_pNDotLEffect->OnResetDevice() );
  76.  
  77.     return S_OK;
  78. }
  79.  
  80.  
  81. //--------------------------------------------------------------------------------------
  82. // This function loads the mesh and ensures the mesh has normals; it also optimizes the 
  83. // mesh for the graphics card's vertex cache, which improves performance by organizing 
  84. // the internal triangle list for less cache misses.
  85. //--------------------------------------------------------------------------------------
  86. HRESULT CPRTMesh::LoadMesh( IDirect3DDevice9* pd3dDevice, WCHAR* strMeshFileName )
  87. {
  88.     WCHAR str[MAX_PATH];
  89.     HRESULT hr;
  90.  
  91.     // Release any previous mesh object
  92.     SAFE_RELEASE(m_pMesh);
  93.     SAFE_RELEASE(m_pMaterialBuffer);
  94.     for(int i=0; i<m_pAlbedoTextures.GetSize(); i++ )
  95.     {
  96.         SAFE_RELEASE( m_pAlbedoTextures[i] );
  97.     }
  98.     m_pAlbedoTextures.RemoveAll();
  99.  
  100.     // Load the mesh object
  101.     V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, strMeshFileName ) );
  102.     wcscpy( m_ReloadState.strMeshFileName, str );
  103.     V_RETURN( D3DXLoadMeshFromX( str, D3DXMESH_MANAGED, pd3dDevice, NULL, 
  104.                                  &m_pMaterialBuffer, NULL, &m_dwNumMaterials, &m_pMesh) );
  105.     m_pMaterials = (D3DXMATERIAL*)m_pMaterialBuffer->GetBufferPointer();
  106.  
  107.     // Change the current directory to the mesh's directory so we can
  108.     // find the textures.
  109.     WCHAR* pLastSlash = wcsrchr( str, L'\\' );
  110.     if( pLastSlash )
  111.         *(pLastSlash + 1) = 0;
  112.     WCHAR strCWD[MAX_PATH];
  113.     GetCurrentDirectory( MAX_PATH, strCWD );
  114.     SetCurrentDirectory( str );
  115.  
  116.     // Lock the vertex buffer to get the object's radius & center
  117.     // simply to help position the camera a good distance away from the mesh.
  118.     IDirect3DVertexBuffer9* pVB = NULL;
  119.     void* pVertices;
  120.     V_RETURN( m_pMesh->GetVertexBuffer( &pVB ) );
  121.     V_RETURN( pVB->Lock( 0, 0, &pVertices, 0 ) );
  122.  
  123.     D3DVERTEXELEMENT9 Declaration[MAXD3DDECLLENGTH + 1];
  124.     m_pMesh->GetDeclaration( Declaration );
  125.     DWORD dwStride = D3DXGetDeclVertexSize( Declaration, 0 );
  126.     V_RETURN( D3DXComputeBoundingSphere( (D3DXVECTOR3*)pVertices, m_pMesh->GetNumVertices(), 
  127.                                           dwStride, &m_vObjectCenter, 
  128.                                           &m_fObjectRadius ) );
  129.  
  130.     pVB->Unlock();
  131.     SAFE_RELEASE( pVB );
  132.  
  133.     // Make the mesh have a known decl in order to pass per vertex CPCA 
  134.     // data to the shader
  135.     V_RETURN( AdjustMeshDecl( pd3dDevice, &m_pMesh ) );
  136.  
  137.     // Optimize the mesh for this graphics card's vertex cache 
  138.     // so when rendering the mesh's triangle list the vertices will 
  139.     // cache hit more often so it won't have to re-execute the vertex shader 
  140.     // on those vertices so it will improve perf.     
  141.     DWORD *rgdwAdjacency = NULL;
  142.     rgdwAdjacency = new DWORD[m_pMesh->GetNumFaces() * 3];
  143.     if( rgdwAdjacency == NULL )
  144.         return E_OUTOFMEMORY;
  145.     V( m_pMesh->ConvertPointRepsToAdjacency(NULL, rgdwAdjacency) );
  146.     V( m_pMesh->OptimizeInplace( D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_IGNOREVERTS, 
  147.                                  rgdwAdjacency, NULL, NULL, NULL) );
  148.     delete []rgdwAdjacency;
  149.  
  150.     for(UINT i=0; i<m_dwNumMaterials; i++ )
  151.     {
  152.         // First attempt to look for texture in the same folder as the input folder.
  153.         WCHAR strTextureTemp[MAX_PATH];
  154.         MultiByteToWideChar( CP_ACP, 0, m_pMaterials[i].pTextureFilename, -1, strTextureTemp, MAX_PATH );
  155.         strTextureTemp[MAX_PATH-1] = 0;
  156.  
  157.         // Create the mesh texture from a file
  158.         if( SUCCEEDED( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, strTextureTemp ) ) )
  159.         {
  160.             IDirect3DTexture9* pAlbedoTexture;
  161.             V( D3DXCreateTextureFromFileEx( pd3dDevice, str, D3DX_DEFAULT, D3DX_DEFAULT, 
  162.                                             D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, 
  163.                                             D3DX_DEFAULT, D3DX_DEFAULT, 0, 
  164.                                             NULL, NULL, &pAlbedoTexture ) );
  165.             m_pAlbedoTextures.Add( pAlbedoTexture );
  166.         }
  167.         else
  168.         {
  169.             m_pAlbedoTextures.Add( NULL );
  170.         }
  171.     }
  172.    
  173.     SetCurrentDirectory( strCWD );
  174.  
  175.     return S_OK;
  176. }
  177.  
  178.  
  179. //--------------------------------------------------------------------------------------
  180. HRESULT CPRTMesh::SetMesh( IDirect3DDevice9* pd3dDevice, ID3DXMesh* pMesh )
  181. {
  182.     HRESULT hr;
  183.  
  184.     // Release any previous mesh object
  185.     SAFE_RELEASE(m_pMesh);
  186.  
  187.     m_pMesh = pMesh;
  188.  
  189.     V( AdjustMeshDecl( pd3dDevice, &m_pMesh ) );
  190.  
  191.     // Sort the attributes
  192.     DWORD *rgdwAdjacency = NULL;
  193.     rgdwAdjacency = new DWORD[m_pMesh->GetNumFaces() * 3];
  194.     if( rgdwAdjacency == NULL )
  195.         return E_OUTOFMEMORY;
  196.     V( m_pMesh->ConvertPointRepsToAdjacency(NULL, rgdwAdjacency) );
  197.     V( m_pMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_IGNOREVERTS, 
  198.                                 rgdwAdjacency, NULL, NULL, NULL) );
  199.     delete []rgdwAdjacency;
  200.  
  201.     return S_OK;
  202. }
  203.  
  204.  
  205. //-----------------------------------------------------------------------------
  206. // Make the mesh have a known decl in order to pass per vertex CPCA 
  207. // data to the shader
  208. //-----------------------------------------------------------------------------
  209. HRESULT CPRTMesh::AdjustMeshDecl( IDirect3DDevice9* pd3dDevice, ID3DXMesh** ppMesh )
  210. {
  211.     HRESULT hr;
  212.     LPD3DXMESH pInMesh = *ppMesh;
  213.     LPD3DXMESH pOutMesh = NULL;
  214.  
  215.     D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE] = 
  216.     {
  217.         {0,  0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
  218.         {0,  12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
  219.         {0,  24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
  220.         {0,  32, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
  221.         {0,  36, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 1},
  222.         {0,  52, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 2},
  223.         {0,  68, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 3},
  224.         {0,  84, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 4},
  225.         {0, 100, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 5},
  226.         {0, 116, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 6},
  227.         D3DDECL_END()
  228.     };
  229.  
  230.     // To do CPCA, we need to store (g_dwNumPCAVectors + 1) scalers per vertex, so 
  231.     // make the mesh have a known decl to store this data.  Since we can't do 
  232.     // skinning and PRT at once, we use D3DDECLUSAGE_BLENDWEIGHT[0] 
  233.     // to D3DDECLUSAGE_BLENDWEIGHT[6] to store our per vertex data needed for PRT.
  234.     // Notice that D3DDECLUSAGE_BLENDWEIGHT[0] is a float1, and
  235.     // D3DDECLUSAGE_BLENDWEIGHT[1]-D3DDECLUSAGE_BLENDWEIGHT[6] are float4.  This allows 
  236.     // up to 24 PCA weights and 1 float that gives the vertex shader 
  237.     // an index into the vertex's cluster's data
  238.     V( pInMesh->CloneMesh( pInMesh->GetOptions(), decl, pd3dDevice, &pOutMesh ) );
  239.  
  240.     // Make sure there are normals which are required for lighting
  241.     if( !(pInMesh->GetFVF() & D3DFVF_NORMAL) )
  242.         V( D3DXComputeNormals( pOutMesh, NULL ) );
  243.  
  244.     SAFE_RELEASE( pInMesh );
  245.  
  246.     *ppMesh = pOutMesh;
  247.  
  248.     return S_OK;
  249. }
  250.  
  251.  
  252. //--------------------------------------------------------------------------------------
  253. HRESULT CPRTMesh::LoadPRTBufferFromFile( WCHAR* strFile )
  254. {
  255.     HRESULT hr;
  256.     SAFE_RELEASE( m_pPRTBuffer );
  257.     SAFE_RELEASE( m_pPRTCompBuffer );
  258.  
  259.     WCHAR str[MAX_PATH];
  260.     V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, strFile ) );
  261.     wcscpy( m_ReloadState.strPRTBufferFileName, str );
  262.  
  263.     V( D3DXLoadPRTBufferFromFile( str, &m_pPRTBuffer ) );
  264.     m_dwOrder = GetOrderFromNumCoeffs( m_pPRTBuffer->GetNumCoeffs() );
  265.     return S_OK;
  266. }
  267.  
  268.  
  269. //--------------------------------------------------------------------------------------
  270. HRESULT CPRTMesh::LoadCompPRTBufferFromFile( WCHAR* strFile )
  271. {
  272.     HRESULT hr;
  273.     SAFE_RELEASE( m_pPRTBuffer );
  274.     SAFE_RELEASE( m_pPRTCompBuffer );
  275.  
  276.     WCHAR str[MAX_PATH];
  277.     V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, strFile ) );
  278.     wcscpy( m_ReloadState.strPRTBufferFileName, str );
  279.  
  280.     V( D3DXLoadPRTCompBufferFromFile( str, &m_pPRTCompBuffer ) );
  281.     m_ReloadState.bUseReloadState = true;
  282.     m_ReloadState.bLoadCompressed = true;
  283.     m_dwOrder = GetOrderFromNumCoeffs( m_pPRTCompBuffer->GetNumCoeffs() );
  284.     return S_OK;
  285. }
  286.  
  287.  
  288. //--------------------------------------------------------------------------------------
  289. void CPRTMesh::CompressBuffer( D3DXSHCOMPRESSQUALITYTYPE Quality, UINT NumClusters, UINT NumPCA )
  290. { 
  291.     HRESULT hr;
  292.     assert( m_pPRTBuffer != NULL );
  293.     SAFE_RELEASE(m_pPRTCompBuffer);
  294.     V( D3DXCreatePRTCompBuffer( Quality, NumClusters, NumPCA, m_pPRTBuffer, &m_pPRTCompBuffer ) );
  295.     m_ReloadState.quality = Quality;
  296.     m_ReloadState.dwNumClusters = NumClusters;
  297.     m_ReloadState.dwNumPCA = NumPCA;
  298.     m_ReloadState.bUseReloadState = true;
  299.     m_ReloadState.bLoadCompressed = false;
  300.     m_dwOrder = GetOrderFromNumCoeffs( m_pPRTBuffer->GetNumCoeffs() );
  301. }
  302.  
  303.  
  304. //--------------------------------------------------------------------------------------
  305. void CPRTMesh::SetPRTBuffer( ID3DXPRTBuffer* pPRTBuffer, WCHAR* strFile ) 
  306. { 
  307.     SAFE_RELEASE(m_pPRTBuffer);
  308.     SAFE_RELEASE(m_pPRTCompBuffer);
  309.     m_pPRTBuffer = pPRTBuffer;
  310.     m_dwOrder = GetOrderFromNumCoeffs( m_pPRTBuffer->GetNumCoeffs() );
  311.     wcsncpy( m_ReloadState.strPRTBufferFileName, strFile, MAX_PATH );
  312.     m_ReloadState.strPRTBufferFileName[MAX_PATH - 1] = L'\0';
  313. }
  314.  
  315.  
  316. //-----------------------------------------------------------------------------
  317. HRESULT CPRTMesh::LoadEffects( IDirect3DDevice9* pd3dDevice, const D3DCAPS9* pDeviceCaps )
  318. {
  319.     HRESULT hr;
  320.  
  321.     UINT dwNumChannels = m_pPRTCompBuffer->GetNumChannels();
  322.     UINT dwNumClusters = m_pPRTCompBuffer->GetNumClusters();
  323.     UINT dwNumPCA      = m_pPRTCompBuffer->GetNumPCA();
  324.  
  325.     // The number of vertex consts need by the shader can't exceed the 
  326.     // amount the HW can support
  327.     DWORD dwNumVConsts = dwNumClusters * (1 + dwNumChannels*dwNumPCA/4) + 4;
  328.     if( dwNumVConsts > pDeviceCaps->MaxVertexShaderConst )
  329.         return E_FAIL;
  330.  
  331.     SAFE_RELEASE( m_pPRTEffect );
  332.     SAFE_RELEASE( m_pSHIrradEnvMapEffect );
  333.     SAFE_RELEASE( m_pNDotLEffect );
  334.  
  335.     D3DXMACRO aDefines[3];
  336.     CHAR szMaxNumClusters[64];
  337.     sprintf( szMaxNumClusters, "%d", dwNumClusters );
  338.     szMaxNumClusters[63] = 0;
  339.     CHAR szMaxNumPCA[64];
  340.     sprintf( szMaxNumPCA, "%d", dwNumPCA );
  341.     szMaxNumPCA[63] = 0;
  342.     aDefines[0].Name       = "NUM_CLUSTERS";
  343.     aDefines[0].Definition = szMaxNumClusters;
  344.     aDefines[1].Name       = "NUM_PCA";
  345.     aDefines[1].Definition = szMaxNumPCA;
  346.     aDefines[2].Name       = NULL;
  347.     aDefines[2].Definition = NULL;
  348.  
  349.     // Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the shader debugger.  
  350.     // Debugging vertex shaders requires either REF or software vertex processing, and debugging 
  351.     // pixel shaders requires REF.  The D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug 
  352.     // experience in the shader debugger.  It enables source level debugging, prevents instruction 
  353.     // reordering, prevents dead code elimination, and forces the compiler to compile against the next 
  354.     // higher available software target, which ensures that the unoptimized shaders do not exceed 
  355.     // the shader model limitations.  Setting these flags will cause slower rendering since the shaders 
  356.     // will be unoptimized and forced into software.  See the DirectX documentation for more information 
  357.     // about using the shader debugger.
  358.     DWORD dwShaderFlags = 0;
  359.     #ifdef DEBUG_VS
  360.         dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
  361.     #endif
  362.     #ifdef DEBUG_PS
  363.         dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
  364.     #endif
  365.         
  366.     // Read the D3DX effect file
  367.     WCHAR str[MAX_PATH];
  368.     V( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, TEXT("PRTColorLights.fx") ) );
  369.  
  370.     // If this fails, there should be debug output as to 
  371.     // they the .fx file failed to compile
  372.     V( D3DXCreateEffectFromFile( pd3dDevice, str, aDefines, NULL, 
  373.                                  dwShaderFlags, NULL, &m_pPRTEffect, NULL ) );
  374.  
  375.     // Make sure the technique works on this card
  376.     hr = m_pPRTEffect->ValidateTechnique( "RenderWithPRTColorLights" );
  377.     if( FAILED( hr ) )
  378.         return DXTRACE_ERR( TEXT("ValidateTechnique"), hr );
  379.  
  380.     V( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, TEXT("SimpleLighting.fx") ) );
  381.     V( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, 
  382.                                  dwShaderFlags, NULL, &m_pNDotLEffect, NULL ) );
  383.  
  384.     V( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, TEXT("SHIrradianceEnvMap.fx") ) );
  385.     V( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, 
  386.                                  dwShaderFlags, NULL, &m_pSHIrradEnvMapEffect, NULL ) );
  387.  
  388.     return S_OK;
  389. }
  390.  
  391.  
  392. //--------------------------------------------------------------------------------------
  393. void CPRTMesh::ExtractCompressedDataForPRTShader() 
  394. { 
  395.     HRESULT hr;
  396.  
  397.     // First call ID3DXPRTCompBuffer::NormalizeData.  This isn't nessacary, 
  398.     // but it makes it easier to use data formats that have little presision.
  399.     // It normalizes the PCA weights so that they are between [-1,1]
  400.     // and modifies the basis vectors accordingly.  
  401.     V( m_pPRTCompBuffer->NormalizeData() );
  402.  
  403.     UINT dwNumSamples  = m_pPRTCompBuffer->GetNumSamples();
  404.     UINT dwNumCoeffs   = m_pPRTCompBuffer->GetNumCoeffs();
  405.     UINT dwNumChannels = m_pPRTCompBuffer->GetNumChannels();
  406.     UINT dwNumClusters = m_pPRTCompBuffer->GetNumClusters();
  407.     UINT dwNumPCA      = m_pPRTCompBuffer->GetNumPCA();
  408.  
  409.     // With clustered PCA, each vertex is assigned to a cluster.  To figure out 
  410.     // which vertex goes with which cluster, call ID3DXPRTCompBuffer::ExtractClusterIDs.
  411.     // This will return a cluster ID for every vertex.  Simply pass in an array of UINTs
  412.     // that is the size of the number of vertices (which also equals the number of samples), and 
  413.     // the cluster ID for vertex N will be at puClusterIDs[N].
  414.     UINT* pClusterIDs = new UINT[ dwNumSamples ];
  415.     assert( pClusterIDs );
  416.     V( m_pPRTCompBuffer->ExtractClusterIDs( pClusterIDs ) );
  417.  
  418.     D3DVERTEXELEMENT9 declCur[MAX_FVF_DECL_SIZE];
  419.     m_pMesh->GetDeclaration( declCur );
  420.  
  421.     // Now use this cluster ID info to store a value in the mesh in the 
  422.     // D3DDECLUSAGE_BLENDWEIGHT[0] which is declared in the vertex decl to be a float1
  423.     // This value will be passed into the vertex shader to allow the shader 
  424.     // use this number as an offset into an array of shader constants.  
  425.     // The value we set per vertex is based on the cluster ID and the stride 
  426.     // of the shader constants array.  
  427.     BYTE* pV = NULL;
  428.     V( m_pMesh->LockVertexBuffer( 0, (void**) &pV ) );
  429.     UINT uStride = m_pMesh->GetNumBytesPerVertex();
  430.     BYTE* pClusterID = pV + 32; // 32 == D3DDECLUSAGE_BLENDWEIGHT[0] offset
  431.     for( UINT uVert = 0; uVert < dwNumSamples; uVert++ ) 
  432.     {
  433.         float fArrayOffset = (float)(pClusterIDs[uVert] * (1+3*(dwNumPCA/4))); 
  434.         memcpy(pClusterID, &fArrayOffset, sizeof(float));
  435.         pClusterID += uStride;
  436.     }
  437.     m_pMesh->UnlockVertexBuffer();
  438.     SAFE_DELETE_ARRAY(pClusterIDs);
  439.  
  440.     // Now we also need to store the per vertex PCA weights.  Earilier when
  441.     // the mesh was loaded, we changed the vertex decl to make room to store these
  442.     // PCA weights.  In this sample, we will use D3DDECLUSAGE_BLENDWEIGHT[1] to 
  443.     // D3DDECLUSAGE_BLENDWEIGHT[6].  Using D3DDECLUSAGE_BLENDWEIGHT intead of some other 
  444.     // usage was an arbritatey decision.  Since D3DDECLUSAGE_BLENDWEIGHT[1-6] were 
  445.     // declared as float4 then we can store up to 6*4 PCA weights per vertex.  They don't
  446.     // have to be declared as float4, but its a reasonable choice.  So for example, 
  447.     // if dwNumPCAVectors=16 the function will write data to D3DDECLUSAGE_BLENDWEIGHT[1-4]
  448.     V( m_pPRTCompBuffer->ExtractToMesh( dwNumPCA, D3DDECLUSAGE_BLENDWEIGHT, 1, m_pMesh ) );
  449.  
  450.     // Extract the cluster bases into a large array of floats.  
  451.     // ID3DXPRTCompBuffer::ExtractBasis will extract the basis 
  452.     // for a single cluster.  
  453.     //
  454.     // A single cluster basis is an array of
  455.     // (NumPCA+1)*NumCoeffs*NumChannels floats
  456.     // The "1+" is for the cluster mean.
  457.     int nClusterBasisSize = (dwNumPCA+1) * dwNumCoeffs * dwNumChannels;  
  458.     int nBufferSize       = nClusterBasisSize * dwNumClusters; 
  459.  
  460.     SAFE_DELETE_ARRAY( m_aClusterBases );
  461.     m_aClusterBases = new float[nBufferSize];
  462.     assert( m_aClusterBases );
  463.  
  464.     for( DWORD iCluster = 0; iCluster < dwNumClusters; iCluster++ ) 
  465.     {
  466.         // ID3DXPRTCompBuffer::ExtractBasis() extracts the basis for a single cluster at a time.
  467.         V( m_pPRTCompBuffer->ExtractBasis( iCluster, &m_aClusterBases[iCluster * nClusterBasisSize] ) );
  468.     }
  469.  
  470.     SAFE_DELETE_ARRAY( m_aPRTConstants );
  471.     m_aPRTConstants = new float[dwNumClusters*(4+dwNumChannels*dwNumPCA)];
  472.     assert( m_aPRTConstants );
  473. }
  474.  
  475.  
  476. //--------------------------------------------------------------------------------------
  477. void CPRTMesh::ComputeSHIrradEnvMapConstants( float* pSHCoeffsRed, float* pSHCoeffsGreen, float* pSHCoeffsBlue )
  478. { 
  479.     HRESULT hr;
  480.  
  481.     float* fLight[3] = { pSHCoeffsRed, pSHCoeffsGreen, pSHCoeffsBlue };
  482.  
  483.     // Lighting environment coefficients
  484.     D3DXVECTOR4 vCoefficients[3];
  485.  
  486.     // These constants are described in the article by Peter-Pike Sloan titled 
  487.     // "Efficient Evaluation of Irradiance Environment Maps" in the book 
  488.     // "ShaderX 2 - Shader Programming Tips and Tricks" by Wolfgang F. Engel.
  489.     static const float s_fSqrtPI = ((float)sqrtf(D3DX_PI));
  490.     const float fC0 = 1.0f/(2.0f*s_fSqrtPI);
  491.     const float fC1 = (float)sqrt(3.0f)/(3.0f*s_fSqrtPI);
  492.     const float fC2 = (float)sqrt(15.0f)/(8.0f*s_fSqrtPI);
  493.     const float fC3 = (float)sqrt(5.0f)/(16.0f*s_fSqrtPI);
  494.     const float fC4 = 0.5f*fC2;
  495.  
  496.     for( int iChannel=0; iChannel<3; iChannel++ )
  497.     {
  498.         vCoefficients[iChannel].x = -fC1*fLight[iChannel][3];
  499.         vCoefficients[iChannel].y = -fC1*fLight[iChannel][1];
  500.         vCoefficients[iChannel].z =  fC1*fLight[iChannel][2];
  501.         vCoefficients[iChannel].w =  fC0*fLight[iChannel][0] - fC3*fLight[iChannel][6];
  502.     }
  503.  
  504.     V( m_pSHIrradEnvMapEffect->SetVector( "cAr", &vCoefficients[0] ) );
  505.     V( m_pSHIrradEnvMapEffect->SetVector( "cAg", &vCoefficients[1] ) );
  506.     V( m_pSHIrradEnvMapEffect->SetVector( "cAb", &vCoefficients[2] ) );
  507.  
  508.     for( iChannel=0; iChannel<3; iChannel++ )
  509.     {
  510.         vCoefficients[iChannel].x =      fC2*fLight[iChannel][4];
  511.         vCoefficients[iChannel].y =     -fC2*fLight[iChannel][5];
  512.         vCoefficients[iChannel].z = 3.0f*fC3*fLight[iChannel][6];
  513.         vCoefficients[iChannel].w =     -fC2*fLight[iChannel][7];
  514.     }
  515.  
  516.     V( m_pSHIrradEnvMapEffect->SetVector( "cBr", &vCoefficients[0] ) );
  517.     V( m_pSHIrradEnvMapEffect->SetVector( "cBg", &vCoefficients[1] ) );
  518.     V( m_pSHIrradEnvMapEffect->SetVector( "cBb", &vCoefficients[2] ) );
  519.  
  520.     vCoefficients[0].x = fC4*fLight[0][8];
  521.     vCoefficients[0].y = fC4*fLight[1][8];
  522.     vCoefficients[0].z = fC4*fLight[2][8];
  523.     vCoefficients[0].w = 1.0f;
  524.  
  525.     V( m_pSHIrradEnvMapEffect->SetVector( "cC", &vCoefficients[0] ) );
  526. }
  527.  
  528.  
  529. //--------------------------------------------------------------------------------------
  530. void CPRTMesh::ComputeShaderConstants( float* pSHCoeffsRed, float* pSHCoeffsGreen, float* pSHCoeffsBlue, DWORD dwNumCoeffsPerChannel )
  531. {
  532.     HRESULT hr;
  533.     assert( dwNumCoeffsPerChannel == m_pPRTCompBuffer->GetNumCoeffs() );
  534.  
  535.     UINT dwNumCoeffs   = m_pPRTCompBuffer->GetNumCoeffs();
  536.     UINT dwOrder       = m_dwOrder;
  537.     UINT dwNumChannels = m_pPRTCompBuffer->GetNumChannels();
  538.     UINT dwNumClusters = m_pPRTCompBuffer->GetNumClusters();
  539.     UINT dwNumPCA      = m_pPRTCompBuffer->GetNumPCA();
  540.  
  541.     //
  542.     // With compressed PRT, a single diffuse channel is caluated by:
  543.     //       R[p] = (M[k] dot L') + sum( w[p][j] * (B[k][j] dot L');
  544.     // where the sum runs j between 0 and # of PCA vectors
  545.     //       R[p] = exit radiance at point p
  546.     //       M[k] = mean of cluster k 
  547.     //       L' = source radiance approximated with SH coefficients
  548.     //       w[p][j] = the j'th PCA weight for point p
  549.     //       B[k][j] = the j'th PCA basis vector for cluster k
  550.     //
  551.     // Note: since both (M[k] dot L') and (B[k][j] dot L') can be computed on the CPU, 
  552.     // these values are passed as constants using the array m_aPRTConstants.   
  553.     // 
  554.     // So we compute an array of floats, m_aPRTConstants, here.
  555.     // This array is the L' dot M[k] and L' dot B[k][j].
  556.     // The source radiance is the lighting environment in terms of spherical
  557.     // harmonic coefficients which can be computed with D3DXSHEval* or D3DXSHProjectCubeMap.  
  558.     // M[k] and B[k][j] are also in terms of spherical harmonic basis coefficients 
  559.     // and come from ID3DXPRTCompBuffer::ExtractBasis().
  560.     //
  561.     DWORD dwClusterStride = dwNumChannels*dwNumPCA + 4;
  562.     DWORD dwBasisStride = dwNumCoeffs*dwNumChannels*(dwNumPCA + 1);  
  563.  
  564.     for( DWORD iCluster = 0; iCluster < dwNumClusters; iCluster++ ) 
  565.     {
  566.         // For each cluster, store L' dot M[k] per channel, where M[k] is the mean of cluster k
  567.         m_aPRTConstants[iCluster*dwClusterStride + 0] = D3DXSHDot( dwOrder, &m_aClusterBases[iCluster*dwBasisStride + 0*dwNumCoeffs], pSHCoeffsRed );
  568.         m_aPRTConstants[iCluster*dwClusterStride + 1] = D3DXSHDot( dwOrder, &m_aClusterBases[iCluster*dwBasisStride + 1*dwNumCoeffs], pSHCoeffsGreen );
  569.         m_aPRTConstants[iCluster*dwClusterStride + 2] = D3DXSHDot( dwOrder, &m_aClusterBases[iCluster*dwBasisStride + 2*dwNumCoeffs], pSHCoeffsBlue );
  570.         m_aPRTConstants[iCluster*dwClusterStride + 3] = 0.0f;
  571.  
  572.         // Then per channel we compute L' dot B[k][j], where B[k][j] is the jth PCA basis vector for cluster k
  573.         float* pPCAStart = &m_aPRTConstants[iCluster*dwClusterStride + 4];
  574.         for( DWORD iPCA = 0; iPCA < dwNumPCA; iPCA++ ) 
  575.         {
  576.             int nOffset = iCluster*dwBasisStride + (iPCA+1)*dwNumCoeffs*dwNumChannels;
  577.  
  578.             pPCAStart[0*dwNumPCA + iPCA] = D3DXSHDot( dwOrder, &m_aClusterBases[nOffset + 0*dwNumCoeffs], pSHCoeffsRed );
  579.             pPCAStart[1*dwNumPCA + iPCA] = D3DXSHDot( dwOrder, &m_aClusterBases[nOffset + 1*dwNumCoeffs], pSHCoeffsGreen );
  580.             pPCAStart[2*dwNumPCA + iPCA] = D3DXSHDot( dwOrder, &m_aClusterBases[nOffset + 2*dwNumCoeffs], pSHCoeffsBlue );
  581.         }
  582.     }
  583.  
  584.     V( m_pPRTEffect->SetFloatArray( "aPRTConstants", (float*)m_aPRTConstants, dwNumClusters*(4+dwNumChannels*dwNumPCA) ) );
  585. }
  586.  
  587.  
  588. //--------------------------------------------------------------------------------------
  589. void CPRTMesh::RenderWithPRT( IDirect3DDevice9* pd3dDevice, D3DXMATRIX* pmWorldViewProj, bool bRenderWithAlbedo )
  590. {
  591.     HRESULT hr;
  592.     UINT iPass, cPasses;
  593.  
  594.     m_pPRTEffect->SetMatrix( "g_mWorldViewProjection", pmWorldViewProj );
  595.  
  596.     bool bHasAlbedoTexture = false;
  597.     for(int i=0; i<m_pAlbedoTextures.GetSize(); i++ )
  598.     {
  599.         if( m_pAlbedoTextures.GetAt(i) != NULL )
  600.             bHasAlbedoTexture = true;
  601.     }
  602.     if( !bHasAlbedoTexture )
  603.         bRenderWithAlbedo = false;
  604.  
  605.     if( bRenderWithAlbedo )
  606.     {
  607.         V( m_pPRTEffect->SetTechnique( "RenderWithPRTColorLights" ) );
  608.     }
  609.     else
  610.     {
  611.         V( m_pPRTEffect->SetTechnique( "RenderWithPRTColorLightsNoAlbedo" ) );
  612.     }
  613.  
  614.     if( !bRenderWithAlbedo )
  615.     {
  616.         D3DXCOLOR clrWhite = D3DXCOLOR(1,1,1,1);
  617.         V( m_pPRTEffect->SetValue("MaterialDiffuseColor", &clrWhite, sizeof(D3DCOLORVALUE) ) );
  618.     }
  619.  
  620.     V( m_pPRTEffect->Begin(&cPasses, 0) );
  621.  
  622.     for (iPass = 0; iPass < cPasses; iPass++)
  623.     {
  624.         V( m_pPRTEffect->BeginPass(iPass) );
  625.  
  626.         DWORD dwAttribs = 0;
  627.         V( m_pMesh->GetAttributeTable( NULL, &dwAttribs ) );
  628.         for( DWORD i=0; i<dwAttribs; i++ )
  629.         {            
  630.             if( bRenderWithAlbedo )
  631.             {
  632.                 if( m_pAlbedoTextures.GetSize() > (int) i )
  633.                     V( m_pPRTEffect->SetTexture( "AlbedoTexture", m_pAlbedoTextures.GetAt(i) ) );
  634.  
  635.                 V( m_pPRTEffect->SetValue("MaterialDiffuseColor", &m_pMaterials[i].MatD3D.Diffuse, sizeof(D3DCOLORVALUE) ) );
  636.                 V( m_pPRTEffect->CommitChanges() );
  637.             }
  638.             V( m_pMesh->DrawSubset(i) );
  639.         }
  640.  
  641.         V( m_pPRTEffect->EndPass() );
  642.     }
  643.  
  644.     V( m_pPRTEffect->End() );
  645. }
  646.  
  647.  
  648. //--------------------------------------------------------------------------------------
  649. void CPRTMesh::RenderWithSHIrradEnvMap( IDirect3DDevice9* pd3dDevice, D3DXMATRIX* pmWorldViewProj, bool bRenderWithAlbedo )
  650. {
  651.     HRESULT hr;
  652.     UINT iPass, cPasses;
  653.  
  654.     m_pSHIrradEnvMapEffect->SetMatrix( "g_mWorldViewProjection", pmWorldViewProj );
  655.  
  656.     bool bHasAlbedoTexture = false;
  657.     for(int i=0; i<m_pAlbedoTextures.GetSize(); i++ )
  658.     {
  659.         if( m_pAlbedoTextures.GetAt(i) != NULL )
  660.             bHasAlbedoTexture = true;
  661.     }
  662.     if( !bHasAlbedoTexture )
  663.         bRenderWithAlbedo = false;
  664.  
  665.     if( bRenderWithAlbedo )
  666.     {
  667.         V( m_pSHIrradEnvMapEffect->SetTechnique( "RenderWithSHIrradEnvMap" ) );
  668.     }
  669.     else
  670.     {
  671.         V( m_pSHIrradEnvMapEffect->SetTechnique( "RenderWithSHIrradEnvMapNoAlbedo" ) );
  672.     }
  673.  
  674.     if( !bRenderWithAlbedo )
  675.     {
  676.         D3DXCOLOR clrWhite = D3DXCOLOR(1,1,1,1);
  677.         V( m_pSHIrradEnvMapEffect->SetValue("MaterialDiffuseColor", &clrWhite, sizeof(D3DCOLORVALUE) ) );
  678.     }
  679.  
  680.     V( m_pSHIrradEnvMapEffect->Begin(&cPasses, 0) );
  681.  
  682.     for (iPass = 0; iPass < cPasses; iPass++)
  683.     {
  684.         V( m_pSHIrradEnvMapEffect->BeginPass(iPass) );
  685.  
  686.         DWORD dwAttribs = 0;
  687.         V( m_pMesh->GetAttributeTable( NULL, &dwAttribs ) );
  688.         for( DWORD i=0; i<dwAttribs; i++ )
  689.         {
  690.             if( bRenderWithAlbedo )
  691.             {
  692.                 if( m_pAlbedoTextures.GetSize() > (int) i )
  693.                     V( m_pSHIrradEnvMapEffect->SetTexture( "AlbedoTexture", m_pAlbedoTextures.GetAt(i) ) );
  694.                 V( m_pSHIrradEnvMapEffect->SetValue("MaterialDiffuseColor", &m_pMaterials[i].MatD3D.Diffuse, sizeof(D3DCOLORVALUE) ) );
  695.                 V( m_pSHIrradEnvMapEffect->CommitChanges() );
  696.             }
  697.             V( m_pMesh->DrawSubset(i) );
  698.         }
  699.  
  700.         V( m_pSHIrradEnvMapEffect->EndPass() );
  701.     }
  702.  
  703.     V( m_pSHIrradEnvMapEffect->End() );
  704. }
  705.  
  706.  
  707. //--------------------------------------------------------------------------------------
  708. void CPRTMesh::RenderWithNdotL( IDirect3DDevice9* pd3dDevice, D3DXMATRIX* pmWorldViewProj, D3DXMATRIX* pmWorldInv, bool bRenderWithAlbedo, CDXUTDirectionWidget* aLightControl, int nNumLights, float fLightScale )
  709. {
  710.     HRESULT hr;
  711.     UINT iPass, cPasses;
  712.  
  713.     m_pNDotLEffect->SetMatrix( "g_mWorldViewProjection", pmWorldViewProj );
  714.     m_pNDotLEffect->SetMatrix( "g_mWorldInv", pmWorldInv );
  715.  
  716.     D3DXVECTOR4 vLightDir[10];
  717.     D3DXVECTOR4 vLightsDiffuse[10];
  718.     D3DXVECTOR4 lightOn(1,1,1,1);
  719.     D3DXVECTOR4 lightOff(0,0,0,0);
  720.     lightOn *= fLightScale;
  721.  
  722.     for( int i=0; i<nNumLights; i++ )
  723.         vLightDir[i] = D3DXVECTOR4( aLightControl[i].GetLightDirection(), 0 );
  724.     for( int i=0; i<10; i++ )
  725.         vLightsDiffuse[i] = (nNumLights > i) ? lightOn : lightOff;
  726.  
  727.     bool bHasAlbedoTexture = false;
  728.     for(int i=0; i<m_pAlbedoTextures.GetSize(); i++ )
  729.     {
  730.         if( m_pAlbedoTextures.GetAt(i) != NULL )
  731.             bHasAlbedoTexture = true;
  732.     }
  733.     if( !bHasAlbedoTexture )
  734.         bRenderWithAlbedo = false;
  735.  
  736.     if( bRenderWithAlbedo )
  737.     {
  738.         V( m_pNDotLEffect->SetTechnique( "RenderWithNdotL" ) );
  739.     }
  740.     else
  741.     {
  742.         V( m_pNDotLEffect->SetTechnique( "RenderWithNdotLNoAlbedo" ) );
  743.     }
  744.  
  745.     if( !bRenderWithAlbedo )
  746.     {
  747.         D3DXCOLOR clrWhite = D3DXCOLOR(1,1,1,1);
  748.         V( m_pNDotLEffect->SetValue("MaterialDiffuseColor", &clrWhite, sizeof(D3DCOLORVALUE) ) );
  749.     }
  750.  
  751.     V( m_pNDotLEffect->Begin(&cPasses, 0) );
  752.  
  753.     for (iPass = 0; iPass < cPasses; iPass++)
  754.     {
  755.         V( m_pNDotLEffect->BeginPass(iPass) );
  756.  
  757.         // 10 and 20 are the register constants
  758.         V( pd3dDevice->SetVertexShaderConstantF( 10, (float*)vLightDir, nNumLights ) );
  759.         V( pd3dDevice->SetVertexShaderConstantF( 20, (float*)vLightsDiffuse, 10 ) );
  760.  
  761.         DWORD dwAttribs = 0;
  762.         V( m_pMesh->GetAttributeTable( NULL, &dwAttribs ) );
  763.         for( DWORD i=0; i<dwAttribs; i++ )
  764.         {
  765.             if( bRenderWithAlbedo )
  766.             {
  767.                 if( m_pAlbedoTextures.GetSize() > (int) i )
  768.                     V( m_pNDotLEffect->SetTexture( "AlbedoTexture", m_pAlbedoTextures.GetAt(i) ) );
  769.                 V( m_pNDotLEffect->SetValue("MaterialDiffuseColor", &m_pMaterials[i].MatD3D.Diffuse, sizeof(D3DCOLORVALUE) ) );
  770.                 V( m_pNDotLEffect->CommitChanges() );
  771.             }
  772.             V( m_pMesh->DrawSubset(i) );
  773.         }
  774.  
  775.         V( m_pNDotLEffect->EndPass() );
  776.     }
  777.  
  778.     V( m_pNDotLEffect->End() );
  779. }
  780.  
  781.  
  782. //--------------------------------------------------------------------------------------
  783. void CPRTMesh::OnLostDevice()
  784. {
  785.     HRESULT hr;
  786.     if( m_pPRTEffect )
  787.         V( m_pPRTEffect->OnLostDevice() );
  788.     if( m_pSHIrradEnvMapEffect )
  789.         V( m_pSHIrradEnvMapEffect->OnLostDevice() );
  790.     if( m_pNDotLEffect )
  791.         V( m_pNDotLEffect->OnLostDevice() );
  792. }
  793.  
  794.  
  795. //--------------------------------------------------------------------------------------
  796. void CPRTMesh::OnDestroyDevice()
  797. {
  798.     if( !m_ReloadState.bUseReloadState )
  799.         ZeroMemory( &m_ReloadState, sizeof(RELOAD_STATE) );
  800.  
  801.     SAFE_RELEASE( m_pMesh );
  802.     for(int i=0; i<m_pAlbedoTextures.GetSize(); i++ )
  803.     {
  804.         SAFE_RELEASE( m_pAlbedoTextures[i] );
  805.     }
  806.     m_pAlbedoTextures.RemoveAll();
  807.     SAFE_RELEASE( m_pMaterialBuffer );
  808.     SAFE_RELEASE( m_pPRTBuffer );
  809.     SAFE_RELEASE( m_pPRTCompBuffer );
  810.     SAFE_RELEASE( m_pPRTEffect );
  811.     SAFE_RELEASE( m_pSHIrradEnvMapEffect );
  812.     SAFE_RELEASE( m_pNDotLEffect );
  813. }
  814.  
  815.  
  816. //--------------------------------------------------------------------------------------
  817. UINT CPRTMesh::GetOrderFromNumCoeffs( UINT dwNumCoeffs )
  818. {
  819.     UINT dwOrder=1; 
  820.     while(dwOrder*dwOrder < dwNumCoeffs) 
  821.         dwOrder++;
  822.  
  823.     return dwOrder;
  824. }
  825.  
  826.  
  827.